Programmable code fingerprint

ABSTRACT

A method, computer program product, and system performing a method that includes a processor compiling a description including information to be utilized by programmable logic to recognize a code fingerprint in a program executing in the runtime environment. The method also includes the processor configuring the programmable logic, by loading the description into the programmable logic at a predefined time and obtaining, during runtime of the program, an alert that the programmable logic recognized the code fingerprint in the program.

BACKGROUND

A code fingerprint, referred to herein also as a fingerprint, isspecific processor behavior that occurs when a given section of code isexecuting. This processor behavior includes any recognizable behaviorsuch as a particular sequence of branch prediction hits and misses, aparticular sequence of data cache hits and misses, a particular sequenceof taken and not taken branch instructions, and/or any other behavior orpattern recognizable by hardware. Code fingerprints include, but are notlimited to: data cache hit miss sequences for various cache levels, datacache hit miss sequences for a given instruction at a given cache level,sequences of correct/incorrect predictions for either a code segment orfor a specific set of branches in a code segment, and a branch taken/nottaken history when a given instruction is executed. A code fingerprintmay also be a sequence of values, including but not limited to: asequence of branch target addresses, a sequence of indirect branchtarget addresses, a sequence of addresses loaded by a load instructioneither by a specific instruction or by a sequence of instructions,and/or a sequence of call signatures either for a given function or forall functions.

The number of code fingerprints that a given processor can recognizewhen code is executed in a computing environment is presently limitedbecause different types of hardware are required to recognize differenttypes of behaviors that comprise different code fingerprints. Thus, agiven processor may only recognize a limited number of codefingerprints, which can lead to issues. For example, if recognition of agiven fingerprint is not supported in a computing environment, theruntime environment has no way of confirming that a certain sequence isexecuting. Additionally, a fingerprint recognition apparatus may nothave the capability of recognizing a new types of fingerprint thattoday's rapidly-changing technology may require.

SUMMARY

Shortcomings of the prior art are overcome and additional advantages areprovided through the provision of a computer program product forconfiguring programmable logic to recognize a code fingerprint. Thecomputer program product comprises a storage medium readable by aprocessing circuit and storing instructions for execution by theprocessing circuit for performing a method. The method includes, forinstance: compiling, by a processor in a runtime environment, adescription comprising information to be utilized by programmable logicto recognize a code fingerprint in a program executing in the runtimeenvironment; configuring, by the processor, the programmable logic, byloading the description into the programmable logic at a predefinedtime; and obtaining, by the processor, during runtime of the program, analert that the programmable logic recognized the code fingerprint in theprogram.

Shortcomings of the prior art are overcome and additional advantages areprovided through the provision of a method for configuring programmablelogic to recognize a code fingerprint. The method includes, forinstance: compiling, by the processor in a runtime environment, adescription comprising information to be utilized by programmable logicto recognize a code fingerprint in a program executing in the runtimeenvironment; configuring, by the processor, the programmable logic, byloading the description into the programmable logic at a predefinedtime; and obtaining, by the processor, during runtime of the program, analert that the programmable logic recognized the code fingerprint in theprogram.

Shortcomings of the prior art are overcome and additional advantages areprovided through the provision of a system to configure programmablelogic to recognize a code fingerprint. The system includes a memory, oneor more processor in communication with the memory, and programinstructions executable by the one or more processor via the memory toperform a method. The method includes, for instance: compiling, by aprocessor in a runtime environment, a description comprising informationto be utilized by programmable logic to recognize a code fingerprint ina program executing in the runtime environment; configuring, by theprocessor, the programmable logic, by loading the description into theprogrammable logic at a predefined time; and obtaining, by theprocessor, during runtime of the program, an alert that the programmablelogic recognized the code fingerprint in the program.

Methods and systems relating to one or more aspects are also describedand claimed herein. Further, services relating to one or more aspectsare also described and may be claimed herein.

Additional features and advantages are realized through the techniquesdescribed herein. Other embodiments and aspects are described in detailherein and are considered a part of the claimed aspects. For example,aspects of embodiments of the present invention may also include:compiling, by the processor, a plurality of additional descriptions,wherein each additional description comprises information to be utilizedby the programmable logic to recognize at least one additional codefingerprint in the program executing in the runtime environment;obtaining, by the processor, a request from the runtime environment toconfigure the programmable logic; and based on the obtaining,configuring, by the processor, the programmable logic, by loading atleast one of: the description or at least one additional description ofthe plurality of additional descriptions into the programmable logic, ata predefined time.

Aspects of embodiments of the present invention may also include:generating, by the processor, the description, in a hardware descriptionlanguage.

In and embodiment of the present invention, the description comprises ahardware description and the compiling comprises: utilizing, by theprocessor, a tool chain to compile the hardware description into aconfiguration file.

In some embodiments of the present invention, one of a fieldprogrammable gate array or a field programmable logic array comprisesthe programmable logic.

In an embodiment of the present invention, the description comprises atleast one of a branch-related input or a memory-related input.

In an embodiment of the present invention, a field programmable gatecomprises the programmable logic and the field programmable gate arrayis communicatively coupled to the processor by an input/output bus.

In an embodiment of the present invention, a chip comprises theprogrammable logic and the processor.

In an embodiment of the present invention, the alert comprises alightweight trap.

In an embodiment of the present invention, the predefined time comprisesat least one of: a time of initialization or a time specified by theruntime environment.

Aspects of embodiments of the present invention may also include: basedon obtaining the alert, compiling, by the processor in a runtimeenvironment, a new description comprising new information to be utilizedby the programmable logic to recognize a new code fingerprint in aprogram executing in the runtime environment; configuring, by theprocessor, the programmable logic, the configuring comprising: removingthe description for the programmable logic; and loading the newdescription into the programmable logic; and obtaining, by theprocessor, during runtime of the program, an alert that the programmablelogic recognized the new code fingerprint in the program.

In an embodiment of the present invention, removing the descriptioncomprises moving the description to a buffer as an historical record.

BRIEF DESCRIPTION OF THE DRAWINGS

One or more aspects are particularly pointed out and distinctly claimedas examples in the claims at the conclusion of the specification. Theforegoing and objects, features, and advantages of one or more aspectsare apparent from the following detailed description taken inconjunction with the accompanying drawings in which:

FIG. 1 depicts a computer system that includes aspects of an embodimentof the present invention;

FIG. 2 depicts an example of programmable logic in an embodiment of thepresent invention;

FIG. 3 depicts an example of programmable logic in an embodiment of thepresent invention;

FIG. 4 depicts a workflow incorporating aspects of an embodiment of thepresent invention;

FIG. 5 depicts a workflow incorporating aspects of an embodiment of thepresent invention;

FIG. 6 depicts one embodiment of a cloud computing node;

FIG. 7 depicts one embodiment of a cloud computing environment; and

FIG. 8 depicts one example of abstraction model layers.

DETAILED DESCRIPTION

The accompanying figures, in which like reference numerals refer toidentical or functionally similar elements throughout the separate viewsand which are incorporated in and form a part of the specification,further illustrate the present invention and, together with the detaileddescription of the invention, serve to explain the principles of thepresent invention. As understood by one of skill in the art, theaccompanying figures are provided for ease of understanding andillustrate aspects of certain embodiments of the present invention. Theinvention is not limited to the embodiments depicted in the figures.

As understood by one of skill in the art, program code, as referred tothroughout this application, includes both software and hardware. Forexample, program code in certain embodiments of the present inventionincludes fixed function hardware, while other embodiments utilized asoftware-based implementation of the functionality described. Certainembodiments combine both types of program code.

Embodiments of the present invention include a program code 40 (e.g.,FIG. 6) executed by at least one processor 16 (FIG. 6) that programscertain aspects of this embodiment to recognize a previously unknown,also referred to as an arbitrary code fingerprint. In an embodiment ofthe present invention, the program code 40 is part of a runtimeenvironment of a computer system 12 (FIG. 6). In an embodiment of thepresent invention, the program code 40 utilizes field-programmable logicto program aspects of the present invention to recognize codefingerprints, including but not limited to, arbitrary code fingerprints.

Aspects of certain embodiments of the present invention provide theadvantage of being programmable, both at and after initialization of acomputer system, such that a code fingerprint that was previouslyunknown can be recognized by the program code 40. This functionalityrepresents an improvement to existing computing technology both byincreasing the efficiency of a given system and enhancing the accuracyat which the resources of the system, including but not limited to,program code 40 executing in the system can be optimized. Thisprogrammable aspect represents an improvement to existing computingtechnology as presently, in order to recognize a range of differenttypes of fingerprints, a range of different hardware is required in acomputing environment. Also, once a system has been initialized, nomethod exists for adding previously unanticipated code fingerprints to agroup of code fingerprints that can be recognized by the existingcomputer system. The ability to program a computer system to recognizenew types of code fingerprints increases the efficiency of the system.For example, without the ability to program new fingerprints, a runtimeenvironment in a computer system may rely on a performance monitor toanalyze program behavior, which requires significant additional overheadand does not provide as detailed information. This lack of informationcan lead the runtime environment to provide only suboptimaloptimization. Because aspects of certain embodiments of the presentinvention enable flexibility in the group of code fingerprints that theprogram code 40 can identify, the runtime environment can betteroptimize the computing environment.

Embodiments of the present invention provide program code 40, includingbut not limited to program code 40 that comprises a runtime environment,with the ability to program a programmable logic device, including butnot limited to a hardware or a software device, to recognize a codefingerprint. In an embodiment of the present invention, because theprogram code 40 can program the device to recognize a code fingerprint,it can program the device to recognize any code fingerprint.

As described above, there are many different types of code fingerprintand with the constant advances in technology, new types of codefingerprints emerge. An advantage of certain aspects of the presentinvention in that these aspects enable a runtime environment torecognize any specific fingerprint to exactly match its needs, resultingin much a more precise and improved optimization capability.

FIG. 1 illustrates a computer system 100 which includes certain aspectsof an embodiment of the present invention. The computer system 100includes a Field Programmable Gate Array (FPGA) 110. The FPGA 110 is oneexample of a Field Programmable Logic Array (FPLA) that can be utilizedin embodiments of the present invention. In this example, by accessingthe FPGA 110 and configuring the programmable logic therein, the programcode 40 (FIG. 6) comprising the runtime environment to provide acomputer system with an arbitrary fingerprint recognition capability.The FPGA 110 is merely one example of how certain embodiments of thepresent invention provide program code 40 with programmable logic toconfigure to recognize code fingerprints. As understood by one of skillin the art, this example is provided merely for illustrative purposes.

The FPGA 110 of FIG. 1 includes programmable logic 114 that program code40 (FIG. 6) executing on a processor of the CPU 120 configures in orderto enable the computer system 100, and specifically, in this example,the FPGA 110, to recognize code fingerprints. In this embodiment of thepresent invention, the FPGA 110 is external to the CPU 120 and the FPGA110 and CPU 120 are communicatively coupled by an I/O bus 140.

In the embodiment of FIG. 1, program code 40 configures the programmablelogic 114 in the FPGA 110 at initialization. Additionally, the programcode 40 (i.e., a processor as the program executes) provides inputs tothe FPGA 110, and the FPGA 110 accepts these inputs, at various events130. The inputs which the program code 40 (i.e., processor) sends theFPGA 110 to represent events 130 may include, but are not limited to,branch-related inputs and memory-related inputs. The branch-relatedinputs may include, but are not limited to: branch instructioncompletions, taken branch instruction completions, taken branchinstruction addresses, branch instruction hits, branch misses, callinstruction completions, and/or call signature value. The memory-relatedinputs may include, but are not limited to: load instructioncompletions, load instruction cache hits at each data cache level,and/or load instruction data addresses. These inputs may include, butare not limited to, signals and/or messages. The program 40 routes theinputs into the FPGA 110.

In an embodiment of the present invention, the program code 40 mayprogram the programmable logic 114 using a hardware descriptionlanguage, including but not limited to, In the above diagram, any formof Fingerprint Recognition logic in the FPGA can be programmed using ahardware description language, including but not limited to VHSICHardware Description Language (VHDL) and/or Verilog.

In an embodiment of the present invention, to configure the programmablelogic 114 in the FPGA 110 at initialization or at a later time, theprogram code 40 compiles a hardware description in an FPGA configurationfile. In order to compile the FPGA configuration file, the program code40 may utilize an FPGA tool chain. At initialization or at a later time,the program code 40 loads the compiled file into the FPGA 110.

Although the embodiment pictured in FIG. 1 includes an FPGA 110 that isexternal to a CPU 120, some embodiments of the present invention provideprogrammable logic 114 on the same chip as a microprocessor of the CPU120. Although the functionality of these embodiments would be equivalentto the functionality described in the context of the embodiment in FIG.1, embodiments that provide FPGA-based fingerprint recognition and amicroprocessor on the same chip have the speed and packaging advantagesof on-chip integration.

Some embodiments of the present invention enable the program code 40(e.g., FIG. 6) to reprogram the programmable logic in, for example, anFPGA or an FPLA, after initialization. In these embodiments of thepresent invention, the program code 40 compiles more than one data setthat the programmable logic can utilize to recognize fingerprints. Thesedata sets may be, for example, hardware descriptions in FPGAconfiguration files. The program code 40 would configure theprogrammable logic with the fingerprint criteria in a given data setupon request from the runtime environment. An advantage of embodimentswhere the program code 40 can utilize criteria in multiple data sets isthat they increase the variety of fingerprints that can be used andenable the runtime environment to couple the fingerprint recognitionfunctionality to the needs of the current program.

As aforementioned, in some embodiments of the present invention, theprogram code 40 (e.g., FIG. 6) may configure the programmable logic 114(e.g., FIG. 1), including but not limited to an FPGA 110 (e.g., FIG. 1)and/or an FPLA, to support recognition of any type of fingerprint and/ormultiple types of fingerprints. Some non-limiting examples fingerprintsthat the program code 40 may configure the programmable logic to supportinclude branch-type fingerprints, cache hit/miss-related fingerprints,branch prediction hit/miss fingerprints, and/or histories of a selecteddata values, such as a histories of call signature values, histories ofbranch target addresses, and histories of addresses loaded from.

Although the programmable logic 114 can be configured such that FPGA 110recognizes of any type of fingerprint and/or multiple types offingerprints, for ease of understanding, FIG. 2 provides an example ofthe operation of programmable logic 114 when it is configured by theprogram code 40 to recognize branch-type fingerprints. As understood byone of skill in the art, similar logic could be programmed to additionaltypes of fingerprints, including but not limited to, cachehit/miss-related fingerprints, and/or branch prediction hit/missfingerprints.

Referring to FIG. 2, in an embodiment of the present invention, programcode 40 (e.g., FIG. 6) configured the programmable logic 214 torecognize a fingerprint that includes a Measured Sequence 210. Theprogram code 40 configured the Measured Sequence 210 with a BranchInstruction 212 and a Branch Taken 214 conditional jump. The programcode 40 provides the programmable logic 214 with an Expected Sequence220, which is a sequence from the program executing in the runtimeenvironment of the computer system. Based on receiving the ExpectedSequence 220 from the program code 40, the programmable logic 214compares the Expected Sequence 220 with the fingerprint that is theMeasured Sequence 210. If the sequences match 235, the program code 40received an alert from the programmable logic.

FIG. 1 also depicts the alert aspect of embodiment of the presentinvention. In FIG. 1, the programmable logic 114, in an FPGA 110 alertsthe CPU 120 that the logic programmed by the program code 40 recognizedthe programmed fingerprint by sending alerts 150. In an embodiment ofthe present invention, the programmable logic 114 alerts the runtimeenvironment executing on the CPU 120.

When comparing the sequences, the program code 40 may identify identicalsequences in the registers and/or the program code 40 may identify afuzzy match, which would occur, for example, when a hamming distancebetween the expected and measured sequences is less than a specifiedvalue.

In an embodiment of the present invention, the alert is a trap,including but not limited to, a lightweight trap, such as an EBB.

FIG. 3 depicts an example of the programmable logic 314 that the programcode 40 can configure to histories of a selected data values, including,but not limited to, histories of call signature values, histories ofbranch target addresses, and/or histories of addresses loaded from.

In an embodiment of the present invention, the program code 40 (e.g.,FIG. 6) accesses a configuration register to select a type offingerprint that the programmable logic 314 will recognize. For example,the program code 40 may utilize a Configured Parameter Field 345 in aconfiguration register to selects the type of fingerprint to berecognized (e.g., load instruction addresses, branch instructiontargets, call signatures, etc.). In some embodiments of the presentinvention, the register is part of an FPGA and accessed over the I/O busfrom the CPU. In other embodiments of the present invention, theregister is implemented as part of the CPU with its contents accessiblefrom the FPGA.

An advantage of this embodiment of the present invention is that itmaintains an historical record of fingerprints configured by the programcode 40 in the Configured Parameter Field 345. In the embodiment of FIG.3, an output register, a Measured Sequence Register 330 a is part of aMeasured History Buffer 330. The Measured History Buffer 330 contains ahistory of fingerprints configured, shifted to the Measured SequenceRegister 330 a. When programming logic 314 shifts a new code fingerprintto the Measured Sequence Register 330 a, it shifts the content of theMeasured Sequence Register 330 a, to the first most current historicaloutput register 330 b, shifting the content of this register to thesecond most current historical output register 330 c. The programminglogic 314 downshifts the content of the remaining registers in theMeasured History Buffer 330 accordingly. In an embodiment of the presentinvention, as each such downshift occurs, the program compares theMeasured Sequence History Buffer 330 to an expected history buffer, andif a match between the Measured Sequence History Buffer and an expectedsequence history buffer occurs, the processor may alert the program orother actions may be triggered.

In a multi-processor environment, for example, to guarantee that anyfingerprint recognized represents a behavior of the processor currentlybeing used and not a mixture of behaviors of another processor, programcode 40 can clear the record of fingerprints that are no longerrelevant. For example, in an embodiment such as FIG. 3, the program code40 may clear the Measure Sequence 210 or in an embodiment such as FIG.4, the program code 40 may clear the Measured History Buffer 330, when acontext swap occurs. In an embodiment of the present invention, aftereach context swap, when the program code 40 clears the fingerprintrecord, e.g., register, the programming logic may delay recognizingfingerprints for a predefined period of time and/or for a predefinednumber of instructions to enable transient behavior associated with thecontext swap to diminish, if needed. In an embodiment of the presentinvention, the context swap may include the program code 40re-programming the fingerprint logic (e.g., the FPGA) and/or configuringthe logic to recognize a particular expected sequence, unless the sameexpected sequence is to be recognized for the new program as the oldone.

FIG. 4 depicts a workflow 400 that includes aspects of certainembodiments of the present invention. In an embodiment of the presentinvention, program code 40 (e.g., FIG. 6) in a runtime environmentcompiles a description comprising information to be utilized byprogrammable logic to recognize a code fingerprint in a programexecuting in the runtime environment (410). In an embodiment of thepresent invention, the description includes a hardware description andthe compiling includes the program code 40 utilizing a tool chain tocompile the hardware description into a configuration file. In anembodiment of the present invention, an FGPA or an FPLA comprises theprogrammable logic. In an embodiment of the present invention, prior tocompiling the description, the program code 40 generates the descriptionin a hardware description language.

In an embodiment of the present invention where an FPGA includes theprogrammable logic, the FPGA is communicatively coupled to a processorexecuting the program code 40 by an I/O bus. In an embodiment of thepresent invention, a chip includes the programmable logic and theprocessor.

The program code 40 configures the programmable logic by loading thedescription into the programmable logic at a predefined time (420). Invarious embodiments of the present invention, this predefined time maybe at least one of: a time of initialization or a time specified by theruntime environment.

In an embodiment of the present invention, the description comprises atleast one of a branch-related input or a memory-related input. Duringruntime of the program, the program code 40 obtains an alert that theprogrammable logic recognized the code fingerprint in the program (430).This alert may be a trap, such as a lightweight trap.

In an embodiment of the present invention, the program code 40 compilesa plurality of additional descriptions with each additional descriptionof the plurality including information to be utilized by theprogrammable logic to recognize at least one additional code fingerprintin the program executing in the runtime environment. The program code 40obtains a request from the runtime environment to configure theprogrammable logic. Based on obtaining this request, the program code 40loads at least one of: the description or at least one additionaldescription of the plurality of additional descriptions, into theprogrammable logic, at a predefined time.

FIG. 5 is a workflow 500 that illustrates aspects of some embodiments ofthe present invention. In an embodiment of the present invention, aprocessor in a runtime environment compiles a description that comprisesinformation to be utilized by programmable logic to recognize a codefingerprint in a program executing in the runtime environment (510). Theprocessor configures the programmable logic by loading the descriptioninto the programmable logic at a predefined time (520). The processorobtains, during runtime of the program, an alert that the programmablelogic recognized the code fingerprint in the program (530).

In an embodiment of the present where the description comprises ahardware description and the compiling comprises: the processorutilizing a tool chain to compile the hardware description into aconfiguration file (512).

In an embodiment of the present invention, one of a field programmablegate array or a field programmable logic array comprises theprogrammable logic (514). In an embodiment of the present invention, afield programmable gate comprises the programmable logic and the fieldprogrammable gate array is communicatively coupled to the processor byan input/output bus (516). In an embodiment of the present invention, achip comprises the programmable logic and the processor (518).

In an embodiment of the present invention, the description comprises atleast one of a branch-related input or a memory-related input (519).

In an embodiment of the present invention, the processor generates thedescription, in a hardware description language (505).

In an embodiment of the present invention, the alert comprises alightweight trap (532).

In an embodiment of the present invention, the predefined time comprisesat least one of: a time of initialization or a time specified by theruntime environment (525).

In an embodiment of the present invention, the processor compiles aplurality of additional descriptions, where each additional descriptioncomprises information to be utilized by the programmable logic torecognize at least one additional code fingerprint in the programexecuting in the runtime environment (540). The processor obtains arequest from the runtime environment to configure the programmable logic(550). Based on obtaining the request, the processor configures theprogrammable logic, by loading at least one of: the description or atleast one additional description of the plurality of additionaldescriptions into the programmable logic, at the predefined time (560).

In an embodiment of the present invention, based on obtaining the alert,the processor compiles a new description comprising new information tobe utilized by the programmable logic to recognize a new codefingerprint in a program executing in the runtime environment (542). Theprocessor configures the programmable logic, the configuring comprisesremoving the description for the programmable logic; and loading the newdescription into the programmable logic (552). The removing thedescription may comprise moving the description to a buffer as anhistorical record (554). During runtime of the program, the processorobtains an alert that the programmable logic recognized the new codefingerprint in the program (562).

One or more aspects may relate to cloud computing.

It is understood in advance that although this disclosure includes adetailed description on cloud computing, implementation of the teachingsrecited herein are not limited to a cloud computing environment. Rather,embodiments of the present invention are capable of being implemented inconjunction with any other type of computing environment now known orlater developed.

Cloud computing is a model of service delivery for enabling convenient,on-demand network access to a shared pool of configurable computingresources (e.g. networks, network bandwidth, servers, processing,memory, storage, applications, virtual machines, and services) that canbe rapidly provisioned and released with minimal management effort orinteraction with a provider of the service. This cloud model may includeat least five characteristics, at least three service models, and atleast four deployment models.

Characteristics are as follows:

On-demand self-service: a cloud consumer can unilaterally provisioncomputing capabilities, such as server time and network storage, asneeded automatically without requiring human interaction with theservice's provider.

Broad network access: capabilities are available over a network andaccessed through standard mechanisms that promote use by heterogeneousthin or thick client platforms (e.g., mobile phones, laptops, and PDAs).

Resource pooling: the provider's computing resources are pooled to servemultiple consumers using a multi-tenant model, with different physicaland virtual resources dynamically assigned and reassigned according todemand. There is a sense of location independence in that the consumergenerally has no control or knowledge over the exact location of theprovided resources but may be able to specify location at a higher levelof abstraction (e.g., country, state, or datacenter).

Rapid elasticity: capabilities can be rapidly and elasticallyprovisioned, in some cases automatically, to quickly scale out andrapidly released to quickly scale in. To the consumer, the capabilitiesavailable for provisioning often appear to be unlimited and can bepurchased in any quantity at any time.

Measured service: cloud systems automatically control and optimizeresource use by leveraging a metering capability at some level ofabstraction appropriate to the type of service (e.g., storage,processing, bandwidth, and active user accounts). Resource usage can bemonitored, controlled, and reported providing transparency for both theprovider and consumer of the utilized service.

Service Models are as follows:

Software as a Service (SaaS): the capability provided to the consumer isto use the provider's applications running on a cloud infrastructure.The applications are accessible from various client devices through athin client interface such as a web browser (e.g., web-based email). Theconsumer does not manage or control the underlying cloud infrastructureincluding network, servers, operating systems, storage, or evenindividual application capabilities, with the possible exception oflimited user-specific application configuration settings.

Platform as a Service (PaaS): the capability provided to the consumer isto deploy onto the cloud infrastructure consumer-created or acquiredapplications created using programming languages and tools supported bythe provider. The consumer does not manage or control the underlyingcloud infrastructure including networks, servers, operating systems, orstorage, but has control over the deployed applications and possiblyapplication hosting environment configurations.

Infrastructure as a Service (IaaS): the capability provided to theconsumer is to provision processing, storage, networks, and otherfundamental computing resources where the consumer is able to deploy andrun arbitrary software, which can include operating systems andapplications. The consumer does not manage or control the underlyingcloud infrastructure but has control over operating systems, storage,deployed applications, and possibly limited control of select networkingcomponents (e.g., host firewalls).

Deployment Models are as follows:

Private cloud: the cloud infrastructure is operated solely for anorganization. It may be managed by the organization or a third party andmay exist on-premises or off-premises.

Community cloud: the cloud infrastructure is shared by severalorganizations and supports a specific community that has shared concerns(e.g., mission, security requirements, policy, and complianceconsiderations). It may be managed by the organizations or a third partyand may exist on-premises or off-premises.

Public cloud: the cloud infrastructure is made available to the generalpublic or a large industry group and is owned by an organization sellingcloud services.

Hybrid cloud: the cloud infrastructure is a composition of two or moreclouds (private, community, or public) that remain unique entities butare bound together by standardized or proprietary technology thatenables data and application portability (e.g., cloud bursting for loadbalancing between clouds).

A cloud computing environment is service oriented with a focus onstatelessness, low coupling, modularity, and semantic interoperability.At the heart of cloud computing is an infrastructure comprising anetwork of interconnected nodes.

Referring now to FIG. 6, a schematic of an example of a cloud computingnode is shown. Cloud computing node 10 is only one example of a suitablecloud computing node and is not intended to suggest any limitation as tothe scope of use or functionality of embodiments of the inventiondescribed herein. Regardless, cloud computing node 10 is capable ofbeing implemented and/or performing any of the functionality set forthhereinabove.

In cloud computing node 10 there is a computer system/server 12, whichis operational with numerous other general purpose or special purposecomputing system environments or configurations. Examples of well-knowncomputing systems, environments, and/or configurations that may besuitable for use with computer system/server 12 include, but are notlimited to, personal computer systems, server computer systems, thinclients, thick clients, handheld or laptop devices, multiprocessorsystems, microprocessor-based systems, set top boxes, programmableconsumer electronics, network PCs, minicomputer systems, mainframecomputer systems, and distributed cloud computing environments thatinclude any of the above systems or devices, and the like.

Computer system/server 12 may be described in the general context ofcomputer system-executable instructions, such as program modules, beingexecuted by a computer system. Generally, program modules may includeroutines, programs, objects, components, logic, data structures, and soon that perform particular tasks or implement particular abstract datatypes. Computer system/server 12 may be practiced in distributed cloudcomputing environments where tasks are performed by remote processingdevices that are linked through a communications network. In adistributed cloud computing environment, program modules may be locatedin both local and remote computer system storage media including memorystorage devices.

As shown in FIG. 6, computer system/server 12 in cloud computing node 10is shown in the form of a general-purpose computing device. Thecomponents of computer system/server 12 may include, but are not limitedto, one or more processors or processing units 16, a system memory 28,and a bus 18 that couples various system components including systemmemory 28 to processor 16.

Bus 18 represents one or more of any of several types of bus structures,including a memory bus or memory controller, a peripheral bus, anaccelerated graphics port, and a processor or local bus using any of avariety of bus architectures. By way of example, and not limitation,such architectures include Industry Standard Architecture (ISA) bus,Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, VideoElectronics Standards Association (VESA) local bus, and PeripheralComponent Interconnect (PCI) bus.

Computer system/server 12 typically includes a variety of computersystem readable media. Such media may be any available media that isaccessible by computer system/server 12, and it includes both volatileand non-volatile media, removable and non-removable media.

System memory 28 can include computer system readable media in the formof volatile memory, such as random access memory (RAM) 30 and/or cachememory 32. Computer system/server 12 may further include otherremovable/non-removable, volatile/non-volatile computer system storagemedia. By way of example only, storage system 34 can be provided forreading from and writing to a non-removable, non-volatile magnetic media(not shown and typically called a “hard drive”). Although not shown, amagnetic disk drive for reading from and writing to a removable,non-volatile magnetic disk (e.g., a “floppy disk”), and an optical diskdrive for reading from or writing to a removable, non-volatile opticaldisk such as a CD-ROM, DVD-ROM or other optical media can be provided.In such instances, each can be connected to bus 18 by one or more datamedia interfaces. As will be further depicted and described below,memory 28 may include at least one program product having a set (e.g.,at least one) of program modules that are configured to carry out thefunctions of embodiments of the invention.

Program/utility 40, having a set (at least one) of program modules 42,may be stored in memory 28 by way of example, and not limitation, aswell as an operating system, one or more application programs, otherprogram modules, and program data. Each of the operating system, one ormore application programs, other program modules, and program data orsome combination thereof, may include an implementation of a networkingenvironment. Program modules 42 generally carry out the functions and/ormethodologies of embodiments of the invention as described herein.

Computer system/server 12 may also communicate with one or more externaldevices 14 such as a keyboard, a pointing device, a display 24, etc.;one or more devices that enable a user to interact with computersystem/server 12; and/or any devices (e.g., network card, modem, etc.)that enable computer system/server 12 to communicate with one or moreother computing devices. Such communication can occur via Input/Output(I/O) interfaces 22. Still yet, computer system/server 12 cancommunicate with one or more networks such as a local area network(LAN), a general wide area network (WAN), and/or a public network (e.g.,the Internet) via network adapter 20. As depicted, network adapter 20communicates with the other components of computer system/server 12 viabus 18. It should be understood that although not shown, other hardwareand/or software components could be used in conjunction with computersystem/server 12. Examples include, but are not limited to: microcode,device drivers, redundant processing units, external disk drive arrays,RAID systems, tape drives, and data archival storage systems, etc.

Referring now to FIG. 7, an illustrative cloud computing environment 50is depicted. As shown, cloud computing environment 50 comprises one ormore cloud computing nodes 10 with which local computing devices used bycloud consumers, such as, for example, personal digital assistant (PDA)or cellular telephone 54A, desktop computer 54B, laptop computer 54C,and/or automobile computer system 54N may communicate. Nodes 10 maycommunicate with one another. They may be grouped (not shown) physicallyor virtually, in one or more networks, such as Private, Community,Public, or Hybrid clouds as described hereinabove, or a combinationthereof. This allows cloud computing environment 50 to offerinfrastructure, platforms and/or software as services for which a cloudconsumer does not need to maintain resources on a local computingdevice. It is understood that the types of computing devices 54A-N shownin FIG. 7 are intended to be illustrative only and that computing nodes10 and cloud computing environment 50 can communicate with any type ofcomputerized device over any type of network and/or network addressableconnection (e.g., using a web browser).

Referring now to FIG. 8, a set of functional abstraction layers providedby cloud computing environment 50 (FIG. 6) is shown. It should beunderstood in advance that the components, layers, and functions shownin FIG. 7 are intended to be illustrative only and embodiments of theinvention are not limited thereto. As depicted, the following layers andcorresponding functions are provided:

Hardware and software layer 60 includes hardware and softwarecomponents. Examples of hardware components include mainframes 61; RISC(Reduced Instruction Set Computer) architecture based servers 62;servers 63; blade servers 64; storage devices 65; and networks andnetworking components 66. In some embodiments, software componentsinclude network application server software 67 and database software 68.

Virtualization layer 70 provides an abstraction layer from which thefollowing examples of virtual entities may be provided: virtual servers71; virtual storage 72; virtual networks 73, including virtual privatenetworks; virtual applications and operating systems 74; and virtualclients 75.

In one example, management layer 80 may provide the functions describedbelow, which may include maintaining VPD at a VPD location the computersystem. Resource provisioning 81 provides dynamic procurement ofcomputing resources and other resources that are utilized to performtasks within the cloud computing environment. Metering and Pricing 82provide cost tracking as resources are utilized within the cloudcomputing environment, and billing or invoicing for consumption of theseresources. In one example, these resources may comprise applicationsoftware licenses. Security provides identity verification for cloudconsumers and tasks, as well as protection for data and other resources.User portal 83 provides access to the cloud computing environment forconsumers and system administrators. Service level management 84provides cloud computing resource allocation and management such thatrequired service levels are met. Service Level Agreement (SLA) planningand fulfillment 85 provide pre-arrangement for, and procurement of,cloud computing resources for which a future requirement is anticipatedin accordance with an SLA.

Workloads layer 90 provides examples of functionality for which thecloud computing environment may be utilized. Examples of workloads andfunctions which may be provided from this layer include: mapping andnavigation 91; software development and lifecycle management 92; virtualclassroom education delivery 93; data analytics processing 94;transaction processing 95; and utilizing field-programmable logic torecognize a code fingerprint.

Aspects of the present invention are described herein with reference toflowchart illustrations and/or block diagrams of methods, apparatus(systems), and computer program products according to embodiments of theinvention. It will be understood that each block of the flowchartillustrations and/or block diagrams, and combinations of blocks in theflowchart illustrations and/or block diagrams, can be implemented bycomputer readable program instructions.

These computer readable program instructions may be provided to aprocessor of a general purpose computer, special purpose computer, orother programmable data processing apparatus to produce a machine, suchthat the instructions, which execute via the processor of the computeror other programmable data processing apparatus, create means forimplementing the functions/acts specified in the flowchart and/or blockdiagram block or blocks. These computer readable program instructionsmay also be stored in a computer readable storage medium that can directa computer, a programmable data processing apparatus, and/or otherdevices to function in a particular manner, such that the computerreadable storage medium having instructions stored therein comprises anarticle of manufacture including instructions which implement aspects ofthe function/act specified in the flowchart and/or block diagram blockor blocks.

The computer readable program instructions may also be loaded onto acomputer, other programmable data processing apparatus, or other deviceto cause a series of operational steps to be performed on the computer,other programmable apparatus or other device to produce a computerimplemented process, such that the instructions which execute on thecomputer, other programmable apparatus, or other device implement thefunctions/acts specified in the flowchart and/or block diagram block orblocks.

The flowchart and block diagrams in the Figures illustrate thearchitecture, functionality, and operation of possible implementationsof systems, methods, and computer program products according to variousembodiments of the present invention. In this regard, each block in theflowchart or block diagrams may represent a module, segment, or portionof instructions, which comprises one or more executable instructions forimplementing the specified logical function(s). In some alternativeimplementations, the functions noted in the block may occur out of theorder noted in the figures. For example, two blocks shown in successionmay, in fact, be executed substantially concurrently, or the blocks maysometimes be executed in the reverse order, depending upon thefunctionality involved. It will also be noted that each block of theblock diagrams and/or flowchart illustration, and combinations of blocksin the block diagrams and/or flowchart illustration, can be implementedby special purpose hardware-based systems that perform the specifiedfunctions or acts or carry out combinations of special purpose hardwareand computer instructions.

In addition to the above, one or more aspects may be provided, offered,deployed, managed, serviced, etc. by a service provider who offersmanagement of customer environments. For instance, the service providercan create, maintain, support, etc. computer code and/or a computerinfrastructure that performs one or more aspects for one or morecustomers. In return, the service provider may receive payment from thecustomer under a subscription and/or fee agreement, as examples.Additionally or alternatively, the service provider may receive paymentfrom the sale of advertising content to one or more third parties.

In one aspect, an application may be deployed for performing one or moreembodiments. As one example, the deploying of an application comprisesproviding computer infrastructure operable to perform one or moreembodiments.

As a further aspect, a computing infrastructure may be deployedcomprising integrating computer readable code into a computing system,in which the code in combination with the computing system is capable ofperforming one or more embodiments.

As yet a further aspect, a process for integrating computinginfrastructure comprising integrating computer readable code into acomputer system may be provided. The computer system comprises acomputer readable medium, in which the computer medium comprises one ormore embodiments. The code in combination with the computer system iscapable of performing one or more embodiments.

Although various embodiments are described above, these are onlyexamples. For example, computing environments of other architectures canbe used to incorporate and use one or more embodiments. Further,different instructions, instruction formats, instruction fields and/orinstruction values may be used. Many variations are possible.

Further, other types of computing environments can benefit and be used.As an example, a data processing system suitable for storing and/orexecuting program code is usable that includes at least two processorscoupled directly or indirectly to memory elements through a system bus.The memory elements include, for instance, local memory employed duringactual execution of the program code, bulk storage, and cache memorywhich provide temporary storage of at least some program code in orderto reduce the number of times code must be retrieved from bulk storageduring execution.

Input/Output or I/O devices (including, but not limited to, keyboards,displays, pointing devices, DASD, tape, CDs, DVDs, thumb drives andother memory media, etc.) can be coupled to the system either directlyor through intervening I/O controllers. Network adapters may also becoupled to the system to enable the data processing system to becomecoupled to other data processing systems or remote printers or storagedevices through intervening private or public networks. Modems, cablemodems, and Ethernet cards are just a few of the available types ofnetwork adapters.

The terminology used herein is for the purpose of describing particularembodiments only and is not intended to be limiting. As used herein, thesingular forms “a”, “an” and “the” are intended to include the pluralforms as well, unless the context clearly indicates otherwise. It willbe further understood that the terms “comprises” and/or “comprising”,when used in this specification, specify the presence of statedfeatures, integers, steps, operations, elements, and/or components, butdo not preclude the presence or addition of one or more other features,integers, steps, operations, elements, components and/or groups thereof.

The corresponding structures, materials, acts, and equivalents of allmeans or step plus function elements in the claims below, if any, areintended to include any structure, material, or act for performing thefunction in combination with other claimed elements as specificallyclaimed. The description of one or more embodiments has been presentedfor purposes of illustration and description, but is not intended to beexhaustive or limited to in the form disclosed. Many modifications andvariations will be apparent to those of ordinary skill in the art. Theembodiment was chosen and described in order to best explain variousaspects and the practical application, and to enable others of ordinaryskill in the art to understand various embodiments with variousmodifications as are suited to the particular use contemplated.

What is claimed is:
 1. A computer-implemented method, comprising:compiling, by a processor in a runtime environment, a descriptioncomprising information to be utilized by programmable logic to recognizea code fingerprint in a program executing in the runtime environment;configuring, by the processor, the programmable logic, by loading thedescription into the programmable logic at a predefined time; obtaining,by the processor, during runtime of the program, an alert that theprogrammable logic recognized the code fingerprint in the program; basedon obtaining the alert, compiling, by the processor in a runtimeenvironment, if a new description comprising new information to beutilized by the programmable logic to recognize a new code fingerprintin a program executing in the runtime environment; configuring, by theprocessor, the programmable logic, the configuring comprising: removingthe description for the programmable logic; and loading the newdescription into the programmable logic; and obtaining, by theprocessor, during runtime of the program, an alert that the programmablelogic recognized the new code fingerprint in the program.
 2. Thecomputer-implemented method of claim 1, wherein the descriptioncomprises a hardware description and the compiling comprises: utilizing,by the processor, a tool chain to compile the hardware description intoa configuration file.
 3. The computer-implemented method of claim 1,wherein one of a field programmable gate array or a field programmablelogic array comprises the programmable logic.
 4. Thecomputer-implemented method of claim 1, wherein the descriptioncomprises at least one of a branch-related input or a memory-relatedinput.
 5. The computer-implemented method of claim 1, furthercomprising, generating, by the processor, the description, in a hardwaredescription language.
 6. The computer-implemented method of claim 1,wherein a field programmable gate comprises the programmable logic andthe field programmable gate array is communicatively coupled to theprocessor by an input/output bus.
 7. The computer-implemented method ofclaim 1, wherein a chip comprises the programmable logic and theprocessor.
 8. The computer-implemented method of claim 1, wherein thealert comprises a lightweight trap.
 9. The computer-implemented methodof claim 1, wherein the predefined time comprises at least one of: atime of initialization or a time specified by the runtime environment.10. The computer-implemented method of claim 1, further comprising:compiling, by the processor, a plurality of additional descriptions,wherein each additional description comprises information to be utilizedby the programmable logic to recognize at least one additional codefingerprint in the program executing in the runtime environment;obtaining, by the processor, a request from the runtime environment toconfigure the programmable logic; and based on the obtaining,configuring, by the processor, the programmable logic, by loading atleast one of: the description or at least one additional description ofthe plurality of additional descriptions into the programmable logic, atthe predefined time.
 11. The computer-implemented method of claim 1,wherein the removing the description comprises moving the description toa buffer as an historical record.
 12. A computer program productcomprising: a non-transitory computer readable storage medium readableby one or more processor and storing instructions for execution by theone or more processor for performing a method comprising: compiling, bythe processor in a runtime environment, a description comprisinginformation to be utilized by programmable logic to recognize a codefingerprint in a program executing in the runtime environment;configuring, by the processor, the programmable logic, by loading thedescription into the programmable logic at a predefined time; obtaining,by the processor, during runtime of the program, an alert that theprogrammable logic recognized the code fingerprint in the program; basedon obtaining the alert, compiling, by the processor in a runtimeenvironment, if a new description comprising new information to beutilized by the programmable logic to recognize a new code fingerprintin a program executing in the runtime environment; configuring, by theprocessor, the programmable logic, the configuring comprising: removingthe description for the programmable logic; and loading the newdescription into the programmable logic; and obtaining, by theprocessor, during runtime of the program, an alert that the programmablelogic recognized the new code fingerprint in the program.
 13. Thecomputer program product of claim 12, wherein the description comprisesa hardware description and the compiling comprises: utilizing, by theprocessor, a tool chain to compile the hardware description into aconfiguration file.
 14. The computer program product of claim 12,further comprising, generating, by the processor, the description, in ahardware description language.
 15. The computer program product of claim12, wherein a field programmable gate comprises the programmable logicand the field programmable gate array is communicatively coupled to theprocessor by an input/output bus, or wherein a chip comprises theprogrammable logic and the processor.
 16. The computer program productof claim 12, further comprising: compiling, by the processor, aplurality of additional descriptions, wherein each additionaldescription comprises information to be utilized by the programmablelogic to recognize at least one additional code fingerprint in theprogram executing in the runtime environment; obtaining, by theprocessor, a request from the runtime environment to configure theprogrammable logic; and based on the obtaining, configuring, by theprocessor, the programmable logic, by loading at least one of: thedescription or at least one additional description of the plurality ofadditional descriptions into the programmable logic, at the predefinedtime.
 17. A system comprising: a memory; one or more processor incommunication with the memory; and program instructions executable bythe one or more processor via the memory to perform a method, the methodcomprising: compiling, by the processor in a runtime environment, adescription comprising information to be utilized by programmable logicto recognize a code fingerprint in a program executing in the runtimeenvironment; configuring, by the processor, the programmable logic, byloading the description into the programmable logic at a predefinedtime; obtaining, by the processor, during runtime of the program, analert that the programmable logic recognized the code fingerprint in theprogram; based on obtaining the alert, compiling, by the processor in aruntime environment, if a new description comprising new information tobe utilized by the programmable logic to recognize a new codefingerprint in a program executing in the runtime environment;configuring, by the processor, the programmable logic, the configuringcomprising: removing the description for the programmable logic; andloading the new description into the programmable logic; and obtaining,by the processor, during runtime of the program, an alert that theprogrammable logic recognized the new code fingerprint in the program.18. The system of claim 17, further comprising: compiling, by theprocessor, a plurality of additional descriptions, wherein eachadditional description comprises information to be utilized by theprogrammable logic to recognize at least one additional code fingerprintin the program executing in the runtime environment; obtaining, by theprocessor, a request from the runtime environment to configure theprogrammable logic; and based on the obtaining, configuring, by theprocessor, the programmable logic, by loading at least one of: thedescription or at least one additional description of the plurality ofadditional descriptions into the programmable logic, at a predefinedtime.